package wy;

import java.util.Arrays;
import java.util.Scanner;

/**
 * 网易笔试
 */
public class Main {
    public static void main(String[] args) {
        third();
    }

    private static int MAXLENGTH = 20;

    private static int length;
    private static char[] words = new char[MAXLENGTH];

    private static void Swap(int indexX, int indexY) {
        if (indexX != indexY) {
            char ch = words[indexX];
            words[indexX] = words[indexY];
            words[indexY] = ch;
        }
    }

    private static void InvertArray(int fromIndex, int endIndex) {
        for (; fromIndex < endIndex; ++fromIndex, --endIndex)
            Swap(fromIndex, endIndex);
    }

    private static void Sort(int fromIndex, int endIndex) {
        Arrays.sort(words, fromIndex, endIndex - fromIndex + 1);
    }

    private static void Output() {
        for (int index = 0; index < length; ++index)
            System.out.print(words[index] + " ");
        System.out.println();
    }

    private static void PermutationList() {
        int fromIndex, endIndex, changeIndex;
        Sort(0, length - 1);
        do {
            // 输出一种全排列
            Output();
            fromIndex = endIndex = length - 1;
            // 向前查找第一个变小的元素
            while (fromIndex > 0 && words[fromIndex] < words[fromIndex - 1]) --fromIndex;
            changeIndex = fromIndex;
            if (fromIndex == 0) break;
            // 向后查找最后一个大于words[fromIndex-1]的元素
            while (changeIndex + 1 < length && words[changeIndex + 1] > words[fromIndex - 1]) ++changeIndex;
            Swap(fromIndex - 1, changeIndex);   // 交换两个值
            InvertArray(fromIndex, endIndex);   // 对后面的所有值进行反向处理
        } while (true);
    }

    /// <summary>
    /// 递归方式生成全排列的方法
    /// </summary>
    /// <param name="fromIndex">全排列的起始位置</param>
    /// <param name="endIndex">全排列的终止位置</param>
    private static void PermutationList(int fromIndex, int endIndex) {
        if (fromIndex == endIndex)
            Output();
        else {
            for (int index = fromIndex; index <= endIndex; ++index) {
                // 此处排序主要是为了生成字典序全排列，否则递归会打乱字典序
                Sort(fromIndex, endIndex);
                Swap(fromIndex, index);
                PermutationList(fromIndex + 1, endIndex);
                Swap(fromIndex, index);
            }
        }
    }

    public static void third() {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int k = sc.nextInt();
        int count = 0;
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            if (isValid(i, m, n)) {
                count++;
                if(count==k){
                    System.out.println(toStr(i, n, m));
                    break;
                }
            }
        }
    }

    private static boolean isValid(int i, int m, int n) {
        String str = Integer.toBinaryString(i);
        int count1 = 0;
        int count0 = 0;

        for (int j = 0; j < str.length(); j++) {
            if (str.charAt(j) == '1') count1++;
            else count0++;
            if (count1 > m) return false;
            if (count0 > n) return false;

        }
        return count1 == m;
    }

    private static String toStr(int i, int n, int m) {

        String str = Integer.toBinaryString(i);
        StringBuilder sb = new StringBuilder();
        for (int j = 0; j < n + m - str.length(); j++) {
            sb.append('a');
        }
        for (int j = 0; j < str.length(); j++) {
            if (str.charAt(j) == '0') sb.append('a');
            else sb.append('z');
        }
        return sb.toString();
    }

    public static void second() {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = sc.nextInt() + (i > 0 ? nums[i - 1] : 0);
        }
        int m = sc.nextInt();
        for (int i = 0; i < m; i++) {
            int target = binarySearch(nums, sc.nextInt());
            System.out.println(target);
        }
        sc.close();
    }


    public static int binarySearch(int[] arr, int x) {
        int low = 0;
        int high = arr.length - 1;
        while (low < high) {
            int middle = low + (high - low) / 2;
            if (arr[middle] >= x) {
                high = middle;
            } else {
                low = middle + 1;
            }
        }
        return low + 1;

    }

    public static void first() {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        int[] point = new int[n];
        int[] check = new int[n];
        int[] tmp = new int[n];
        for (int i = 0; i < n; i++) {
            point[i] = scanner.nextInt();
            tmp[i] = point[i];
        }
        for (int i = 0; i < n; i++) {
            check[i] = scanner.nextInt();
            if (check[i] == 1) {
                tmp[i] = 0;
            }
        }
        int max = 0;
        int current = 0;
        int pos = 0;
        for (int i = 0; i < k; i++) {
            current += tmp[i];
        }
        max = current;
        for (int i = 0; i < n - k; i++) {
            current = current - tmp[i] + tmp[i + k];
            if (current > max) {
                max = current;
                pos = i + 1;
            }
        }
        for (int i = 0; i < k; i++) {
            check[pos + i] = 1;
        }
        int sum = 0;
        for (int i = 0; i < n; i++) {
            if (check[i] == 1) {
                sum += point[i];
            }
        }
        System.out.println(sum);
    }
}
/*
5 2 3 7 4 9
3 1 25 11
1
5
3
 */
